/**
 * JZ UnoCSS - 统一CSS规则生成器
 * 将初次遍历生成和用户保存文件生成合并为一套规则
 * @version 1.1.0
 * @author jz
 */

import { generateCSS } from './generator.js';
import { utils } from '../utils/utils.js';

// 导入各个功能模块
import { 
    processGradientClasses, 
    generateConditionalGradientCSS, 
    hasGradientClasses 
} from '../processors/gradient-processor.js';

import { 
    processTransformClasses, 
    generateConditionalTransformCSS, 
    hasTransformClasses 
} from '../processors/transform-processor.js';

import { 
    needsConditionalCompilation, 
    generatePlatformSpecificCSS, 
    generateConditionalCSSRule 
} from '../processors/conditional-compiler.js';

import { 
    generateUniversalCSSRule, 
    generateFullCSSContent, 
    filterCSSStyles, 
    validateCSSRule 
} from '../generators/css-rule-generator.js';

/**
 * 统一的CSS规则生成器
 * 同时支持初次遍历生成和用户保存文件生成
 * @param {string[]} classNames - 类名数组
 * @param {Array} classNameGroups - 类名组合数组
 * @param {Object} config - 配置对象
 * @returns {string[]} CSS规则数组
 */
export function generateUnifiedCSSRules(classNames, classNameGroups, config) {
    // 参数安全检查
    if (!Array.isArray(classNames)) {
        console.warn('[JZ UnoCSS] classNames 不是数组，返回空结果');
        return [];
    }
    
    if (!Array.isArray(classNameGroups)) {
        console.warn('[JZ UnoCSS] classNameGroups 不是数组，使用空数组');
        classNameGroups = [];
    }
    
    if (!config || typeof config !== 'object') {
        console.warn('[JZ UnoCSS] config 不是有效对象，使用默认配置');
        config = {};
    }
    
    const cssRules = [];
    const processedClasses = new Set();
    const processedCombinations = new Set();
    
    // 统一的选项配置
    const options = {
        platform: config.platform || 'H5',  // 允许配置平台，默认H5
        fileType: 'uvue',
        h5Unit: config.h5Unit || 'rem',
        remBase: config.remBase || 16,
        inlineCSS: false,
        mode: config.mode || 'development',
        compileAllPlatforms: config.compileAllPlatforms !== false,  // 是否编译全端代码，默认为true
        preserveConditionalCompilation: config.preserveConditionalCompilation !== false  // 默认保留完整的条件编译代码
    };
    
    let successCount = 0;
    let gradientCount = 0;
    let transformCount = 0;
    let conditionalCount = 0;
    let universalCount = 0;
    
    // 第一阶段：处理渐变组合
    for (const group of classNameGroups) {
        if (hasGradientClasses(group)) {
            try {
                const gradientInfo = processGradientClasses(group, options);
                if (gradientInfo) {
                    const gradientKey = gradientInfo.selector;
                    if (!processedCombinations.has(gradientKey)) {
                        processedCombinations.add(gradientKey);
                        
                        // 渐变通常是通用的，不需要条件编译
                        const gradientCSS = generateConditionalGradientCSS(gradientInfo, options);
                        if (validateCSSRule(gradientCSS)) {
                            cssRules.push(gradientCSS);
                            gradientCount++;
                            successCount++;
                        }
                        
                        // 标记已处理的类名
                        gradientInfo.classNames.forEach(cls => {
                            const decoded = utils.decodeClassNameFromUvue(cls);
                            processedClasses.add(decoded);
                        });
                    }
                }
            } catch (error) {
                console.warn(`[JZ UnoCSS] 处理渐变时出错:`, error.message);
            }
        }
    }
    
    // 第二阶段：处理 Transform 组合
    for (const group of classNameGroups) {
        if (hasTransformClasses(group)) {
            try {
                const transformInfo = processTransformClasses(group, options);
                if (transformInfo) {
                    const transformKey = transformInfo.selector;
                    if (!processedCombinations.has(transformKey)) {
                        processedCombinations.add(transformKey);
                        
                        // Transform通常是通用的，不需要条件编译
                        const transformCSS = generateConditionalTransformCSS(transformInfo, options);
                        if (validateCSSRule(transformCSS)) {
                            cssRules.push(transformCSS);
                            transformCount++;
                        }
                        
                        // 标记已处理的类名
                        transformInfo.classNames.forEach(cls => {
                            const decoded = utils.decodeClassNameFromUvue(cls);
                            processedClasses.add(decoded);
                        });
                    }
                }
            } catch (error) {
                console.warn(`[JZ UnoCSS] 处理Transform时出错:`, error.message);
            }
        }
    }
    
    // 第三阶段：处理单独的类名
    for (const originalClassName of classNames) {
        const decodedClassName = utils.decodeClassNameFromUvue(originalClassName);
        
        // 跳过已处理的类名
        if (processedClasses.has(decodedClassName)) {
            continue;
        }
        processedClasses.add(decodedClassName);
        
        try {
            // 确定编码后的类名（用于HTML选择器）
            let encodedClassName = originalClassName;
            let cssClassName = decodedClassName;
            
            // 检查是否已经是编码的类名
            if (/[LRSKODCMP]/.test(originalClassName)) {
                // 原始类名已经是编码的，解码后用于CSS生成
                cssClassName = decodedClassName;
                encodedClassName = originalClassName;
            } else {
                // 原始类名未编码，直接用于CSS生成
                cssClassName = originalClassName;
                
                // 如果包含特殊字符，进行编码用于HTML选择器
                if (/[/\[\]#(),%.]/.test(originalClassName)) {
                    encodedClassName = utils.encodeClassNameForUvue(originalClassName);
                } else {
                    encodedClassName = originalClassName;
                }
            }
            
            // 先尝试生成条件编译CSS（针对text-ellipsis等特殊类名）
            const conditionalOptions = { ...options, generateConditional: true };
            const conditionalResult = generateCSS(cssClassName, conditionalOptions);
            
            // 如果返回字符串，说明是特殊的条件编译CSS（如text-ellipsis）
            if (typeof conditionalResult === 'string') {
                if (validateCSSRule(conditionalResult)) {
                    cssRules.push(conditionalResult);
                    successCount++;
                    conditionalCount++;
                }
            } else {
                // 使用解码后的类名生成普通CSS样式
                const styles = generateCSS(cssClassName, options);
                
                if (styles && Object.keys(styles).length > 0) {
                    // 智能判断是否需要条件编译
                    const needsConditional = options.forceConditional || needsConditionalCompilation(styles, cssClassName);
                    
                    if (needsConditional) {
                        // 需要条件编译的情况
                        const platformStyles = generatePlatformSpecificCSS(cssClassName, styles, options);
                        const conditionalCSS = generateConditionalCSSRule(encodedClassName, platformStyles, options);
                        
                        if (conditionalCSS && validateCSSRule(conditionalCSS)) {
                            cssRules.push(conditionalCSS);
                            successCount++;
                            conditionalCount++;
                        }
                    } else {
                        // 通用CSS，不需要条件编译
                        const universalCSS = generateUniversalCSSRule(encodedClassName, styles, options);
                        
                        if (universalCSS && validateCSSRule(universalCSS)) {
                            cssRules.push(universalCSS);
                            successCount++;
                            universalCount++;
                        }
                    }
                }
            }
        } catch (error) {
            console.warn(`[JZ UnoCSS] 生成CSS失败 ${originalClassName}:`, error.message);
        }
    }
    
    return cssRules;
}

/**
 * 生成完整的CSS内容（带注释头）
 * @param {string[]} classNames - 类名数组
 * @param {Array} classNameGroups - 类名组合数组
 * @param {Object} config - 配置对象
 * @param {Object} metadata - 元数据对象
 * @returns {string} 完整的CSS内容
 */
export function generateUnifiedCSS(classNames, classNameGroups, config, metadata = {}) {
    const cssRules = generateUnifiedCSSRules(classNames, classNameGroups, config);
    const fullContent = generateFullCSSContent(cssRules, classNames, classNameGroups, config, metadata);
    
    // 确保总是返回数组，即使没有生成CSS规则
    if (fullContent === null || fullContent === undefined) {
        return [];
    }
    
    // 如果返回的是字符串，将其转换为数组
    if (typeof fullContent === 'string') {
        // 拆分CSS规则 - 修复：保留条件编译的CSS块，不过滤注释头
        const rules = fullContent.split(/\n\n/).filter(rule => {
            const trimmed = rule.trim();
            if (!trimmed) return false;
            
            // 保留条件编译CSS块（以 /* text-ellipsis 等开头的完整块）
            if (trimmed.startsWith('/* text-ellipsis') || 
                trimmed.startsWith('/* transform-') ||
                trimmed.startsWith('/* gradient-')) {
                return true;
            }
            
            // 过滤掉纯注释行（但保留CSS规则）
            if (trimmed.startsWith('/*') && !trimmed.includes('{')) {
                return false;
            }
            
            return true;
        });
        return rules;
    }
    
    // 如果已经是数组，直接返回
    return Array.isArray(fullContent) ? fullContent : [];
}

// 向后兼容的别名导出
export const generateCSSRulesWithEncoding = generateUnifiedCSSRules;
export const generateCSSRules = generateUnifiedCSSRules;

// 重新导出各模块的功能供外部使用
export {
    processGradientClasses,
    generateConditionalGradientCSS,
    hasGradientClasses,
    processTransformClasses,
    generateConditionalTransformCSS,
    hasTransformClasses,
    needsConditionalCompilation,
    generatePlatformSpecificCSS,
    generateConditionalCSSRule,
    generateUniversalCSSRule,
    generateFullCSSContent,
    filterCSSStyles,
    validateCSSRule
}; 